package Ptolemaiosz;

import java.util.ArrayList;

public class LevelPartManager {

        private Level level;
        
        
    public LevelPartManager() {
        
                SkeletonLogger.logCall();

                SkeletonLogger.logReturn();
    }

    public LevelPart getNeighbourLevelPart(Direction dir, LevelPart levelpart)
        {
        SkeletonLogger.logCall();

         SkeletonLogger.logReturn();
         ArrayList<ArrayList<LevelPart>> new2darray = level.getneighbour2DArray();

        
                //relevans sorok szamlaloi
                int NumberofRows = 0;
                int NumberofColumns = 0;
                
                // matrix relevans sorai szamanak a meghatarozasa
                for( int row = new2darray.size()-1; row >= 0; row--)
                {
                        for(int column = new2darray.get(row).size()-1; column >= 0; column--)
                        {
                        
                                if (new2darray.get(row).get(column).getId() >= 0)
                                NumberofRows++;
                        }
                };
                
                
                // matrix relevans oszlopai szamanak a meghatarozasa
                        for(int column = 0; column < new2darray.get(0).size(); column++)
                        {
                                if (new2darray.get(0).get(column).getId() >= 0)
                                {
                                        NumberofColumns++;
                                }
                        
                };
                
                //relevans sorok meghatarozsa (oszlopok miatt dupl?n sz?mol?dtak a sorok)
                NumberofRows = NumberofRows / NumberofColumns;
                for( int i = 0; i<NumberofRows; i++)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        {
                                // ha megvan melyik levelpart
                                if (new2darray.get(i).get(j).getId() == levelpart.getId())
                                {
                                        switch (dir)
                                        {
                                                
                                        case up:
                                                //ha van az emptylevelpart felett meg levelpart, akkor visszaadja annak az id-et
                                           if(i > 0)
                                           {
                               LevelPart levelpart_up = new2darray.get(i+1).get(j);
                                                   return levelpart_up;
                                           }
                                           //else return null;
                                           break;
                                           
                                        case down:
                                                //ha van az emptylevelpart alatt meg levelpart, akkor visszaadja annak az id-et
                                           if(i < NumberofRows-1)
                                           {
                                                   LevelPart levelpart_down = new2darray.get(i+1).get(j);
                                                   return levelpart_down;
                                           }
                                           //else return null;
                                           break;
                                           
                                        case right:
                                                //ha van az emptylevelpart mellett jobbra meg levelpart, akkor visszaadja annak az id-et
                                           if( j < NumberofColumns-1)
                                           {
                                                   LevelPart levelpart_right = new2darray.get(i).get(j+1);
                                                   return levelpart_right;
                                           }
                                           //else return null;
                                           break;
                                           
                                        case left:
                                                //ha van az emptylevelpart mellett balra meg levelpart, akkor visszaadja annak az id-et
                                                if( j > 0)
                                                {
                                LevelPart levelpart_left = new2darray.get(i).get(j-1);
                                 return levelpart_left;
                                                }
                                                //else return null;
                                                break;
                                        }
                                }
                        }
                                
                }
        return null;
    };
    
        
public void slide(Direction direction)
{       
        //emptylevelpart hianyaban ne szalljon el
        //es neis csinaljon semmit
        if(level.getEmptyLevelPart().getId() >= 0)
        {
                
                // ideiglenes levelpart
                LevelPart tmplvlpart = new LevelPart();
                
                //lekerjuk a szomszedossagi matrixot
                 ArrayList<ArrayList<LevelPart>> new2darray = new ArrayList<ArrayList<LevelPart>>();
                new2darray = level.getneighbour2DArray();
                
                //sor es oszlop szerint vegighaladva hozzaadjuk a levelpartokat
        for(  int i = 0; i<level.getneighbour2DArray().size(); i++)
        {
                        for(int j=0; j<level.getneighbour2DArray().get(i).size(); j++)
                        {
                                if(level.getneighbour2DArray().get(i).get(j).getId() >= 0)
                                {
                                        new2darray.get(i).set(j, level.getneighbour2DArray().get(i).get(j));
                                }
                        }               
        }
        
        //emptylevelpart sor es oszlop szamlaloinak letrehozasa
                int emptylevelpartRow = 0;
                int emptylevelpartColumn = 0;
                
                //relevans sorok szamlaloi
                int NumberofRows = 0;
                int NumberofColumns = 0;
                
                // matrix relevans sorai szamanak a meghatarozasa
                for( int row = new2darray.size()-1; row >= 0; row--)
                {
                        for(int column = new2darray.get(row).size()-1; column >= 0; column--)
                        {
                        
                                if (new2darray.get(row).get(column).getId() >= 0)
                                NumberofRows++;
                        }
                };
                
                
                // matrix relevans oszlopai szamanak a meghatarozasa
                        for(int column = 0; column < new2darray.get(0).size(); column++)
                        {
                                if (new2darray.get(0).get(column).getId() >= 0)
                                {
                                        NumberofColumns++;
                                }
                        
                };
                
                //relevans sorok meghatarozsa (oszlopok miatt dupl?n sz?mol?dtak a sorok)
                NumberofRows = NumberofRows / NumberofColumns;
                
                // ures palyaszakasz megkeresese a matrixbol
                // es soranak oszlopanak megjegyzese
                for( int row = 0; row < new2darray.size(); row++)
                {
                        for(int column = 0; column < new2darray.get(row).size(); column++)
                        {
                                if (new2darray.get(row).get(column).getId() == level.getEmptyLevelPart().getId())
                                {
                                        emptylevelpartRow = row;
                                        emptylevelpartColumn = column;
                                }
                        };
                };
                
                
                switch (direction) {
                
        case down:
                
                //regi elrendezes kiiratasa
                //sor szerint forditott sorrendben
                //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                //kiirates formatuma
                //[id][id]
                // [x][id]
                Controller.println("palyak regi elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                
                
                                        //sor szerint forditott sorrendben
                                        //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                                        //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                                        //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                                        //kiirates formatuma
                                        //[id][id]
                                        // [x][id]
                                                if ( emptylevelpartRow >= 0 && emptylevelpartRow < NumberofRows-1)
                                    {
                                        tmplvlpart = new2darray.get(emptylevelpartRow).get(emptylevelpartColumn);
                                        new2darray.get(emptylevelpartRow).set(emptylevelpartColumn, new2darray.get(emptylevelpartRow+1).get(emptylevelpartColumn));
                                        new2darray.get(emptylevelpartRow+1).set(emptylevelpartColumn, tmplvlpart) ;
                                     } 
           
                                        //ujelrendezes kiiratasa
                                        //sor szerint forditott sorrendben
                                        //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                                        //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                                        //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                                        //kiirates formatuma
                                        //[id][id]
                                        // [x][id]
                                        Controller.println("palyak uj elrendezese:");
                                        for(  int i = NumberofRows-1; i>=0; i--)
                                        {
                                                for(int j=0; j<NumberofColumns; j++)
                                                { 
                                                                if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                                                Controller.print("[x]");
                                                                
                                                                else
                                                        Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                                        
                                                }
                                                if(new2darray.get(i) != null)
                                                        {
                                                                Controller.println("");
                                                        }
                                        }
                                        Controller.println("");
                
                
                level.setneighbour2DArray(new2darray);
            break;
                
        case up:
                
            //vegigmegyunk sor es oszlop szerint
            //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
            //minden sor utan soremeles
            //kiiratas modja: 
            //[levelpartid][levelpartid]
            //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
      
                Controller.println("palyak regi elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                
                
                //sor szerint forditott sorrendben
                //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                //kiirates formatuma
                //[id][id]
                // [x][id]
            if ( emptylevelpartRow > 0 && emptylevelpartRow <= NumberofRows)
           {
                tmplvlpart = new2darray.get(emptylevelpartRow-1).get(emptylevelpartColumn);
                new2darray.get(emptylevelpartRow-1).set(emptylevelpartColumn, new2darray.get(emptylevelpartRow).get(emptylevelpartColumn));
                new2darray.get(emptylevelpartRow).set(emptylevelpartColumn, tmplvlpart) ;
            } 
            
                //regi elrendezes kiiratasa
            //vegigmegyunk sor es oszlop szerint
            //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
            //minden sor utan soremeles
            //kiiratas modja: 
            //[levelpartid][levelpartid]
            //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
                Controller.println("palyak uj elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                        
                level.setneighbour2DArray(new2darray);
                break;
                    
        case right:
                
                //regi elrendezes kiiratasa
            //vegigmegyunk sor es oszlop szerint
            //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
            //minden sor utan soremeles
            //kiiratas modja: 
            //[levelpartid][levelpartid]
            //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
                Controller.println("palyak regi elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                
                
                
                        //sor szerint forditott sorrendben
                        //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                        //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                        //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                        //kiirates formatuma
                        //[id][id]
                        // [x][id]
                        if ( emptylevelpartColumn > 0 && emptylevelpartColumn < NumberofColumns)
                {
                        tmplvlpart =    new2darray.get(emptylevelpartRow).get(emptylevelpartColumn-1);
                        new2darray.get(emptylevelpartRow).set(emptylevelpartColumn-1, new2darray.get(emptylevelpartRow).get(emptylevelpartColumn));
                        new2darray.get(emptylevelpartRow).set(emptylevelpartColumn, tmplvlpart) ;
                }
                        
                        //uj elrendezes kiiratasa
                //vegigmegyunk sor es oszlop szerint
                //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
                //minden sor utan soremeles
                //kiiratas modja: 
                //[levelpartid][levelpartid]
                //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
                Controller.println("palyak uj elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                                for(int j=0; j<NumberofColumns; j++)
                                { 
                                                if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                                Controller.print("[x]");
                                                
                                                else
                                        Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                        
                                }
                                if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                        
                        
                        level.setneighbour2DArray(new2darray);
                    break;
                                            
        case left:
                
            //vegigmegyunk sor es oszlop szerint
            //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
            //minden sor utan soremeles
            //kiiratas modja: 
            //[levelpartid][levelpartid]
            //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
                Controller.println("palyak regi elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                
                
                //sor szerint forditott sorrendben
                //oszlop szerint novekvo sorrendben vegigmegyunk a matrixon
                //es kiiratjuk az id-ket vagy emptylevelpart eseten [x]-et
                //ertelmetlen soremeleseket kihagyunk ha nincs id-vel rendelkezo elem a sorban
                //kiirates formatuma
                //[id][id]
                // [x][id]
                if ( emptylevelpartColumn >= 0 && emptylevelpartColumn < NumberofColumns-1)
                {
                tmplvlpart = new2darray.get(emptylevelpartRow).get(emptylevelpartColumn+1);
                new2darray.get(emptylevelpartRow).set(emptylevelpartColumn+1, new2darray.get(emptylevelpartRow).get(emptylevelpartColumn));
                new2darray.get(emptylevelpartRow).set(emptylevelpartColumn, tmplvlpart) ;
                }
        
            //vegigmegyunk sor es oszlop szerint
            //sor szerint csokkeno sorrendbe a megfelelo kiiras miatt
            //minden sor utan soremeles
            //kiiratas modja: 
            //[levelpartid][levelpartid]
            //[levelpartid][levelpartid]
                //regi elrendezes kiiratasa
                Controller.println("palyak uj elrendezese:");
                for(  int i = NumberofRows-1; i>=0; i--)
                {
                        for(int j=0; j<NumberofColumns; j++)
                        { 
                                        if ((level.getEmptyLevelPart().getId()) == (new2darray.get(i).get(j).getId()))
                                        Controller.print("[x]");
                                        
                                        else
                                Controller.print("["+new2darray.get(i).get(j).getId()+"]");
                                
                        }
                        if(new2darray.get(i) != null)
                                {
                                        Controller.println("");
                                }
                }
                Controller.println("");
                
                        
                level.setneighbour2DArray(new2darray);
                break;
                    
                }
}
}
        
                
                /* SkeletonLogger.logCall();
                
                //Lekerdezzuk a palyaszakaszokat
                LevelPart[][] neighbour2DArray  = level.getneighbour2DArray();
                //Lekerdezzuk melyik az ures
                level.getEmptyLevelPart();
                //Megvarialjuk a sorrendet, majd visszairjuk
              rA?szleges  level.setneighbour2DArray(neighbour2DArray);
                
                SkeletonLogger.logReturn();*/   

        /**
         * 
         * @param level
         */


        public void setLevel(Level level) {
                /*SkeletonLogger.logCall();
                
                SkeletonLogger.logReturn();
                */
                this.level = level;
        }

        public Level getLevel() {
                /*
                
                SkeletonLogger.logCall();
                
                SkeletonLogger.logReturn();
                */
                
                return this.level;
        }

        /**
         * 
         * @param direction
         */
        public boolean matchChecker(Direction direction, LevelPart levelpart) {

                
                //eredeti elkepzelesetek eleje, de szerintem jo az enyem is
                //ideiglenes levelpart
                 
                LevelPart tmplvlpart = new LevelPart();
                
                //lekerjuk a szomszedossagi matrixot
                 ArrayList<ArrayList<LevelPart>> new2darray = new ArrayList<ArrayList<LevelPart>>();
                new2darray = level.getneighbour2DArray();
                
                ArrayList<Vector> levelpartVertexes = new ArrayList<Vector>();
                ArrayList<Vector> unknownlevelpartVertexes = new ArrayList<Vector>();
                
                int levelpartRow = 100;
                int levelpartColumn = 100;

        int NumberofRows = 0;
        int NumberofColumns = 0;
                // matrix relevans sorai szamanak a meghatarozasa
                for( int row = new2darray.size()-1; row >= 0; row--)
                {
                        for(int column = new2darray.get(row).size()-1; column >= 0; column--)
                        {
                        
                                if (new2darray.get(row).get(column).getId() >= 0)
                                NumberofRows++;
                        }
                };

                
                // matrix relevans oszlopai szamanak a meghatarozasa
                        for(int column = 0; column < new2darray.get(0).size(); column++)
                        {
                                if (new2darray.get(0).get(column).getId() >= 0)
                                {
                                        NumberofColumns++;
                                }
                        
                };
                NumberofRows= NumberofRows/NumberofColumns;
                
                for( int row = 0; row < new2darray.size(); row++)
                {
                        for(int column = 0; column < new2darray.get(row).size(); column++)
                        {
                                if (new2darray.get(row).get(column).getId() == levelpart.getId())
                                {
                                        levelpartRow = row;
                                        levelpartColumn = column;
                                }
                        };
                };


                
                                        switch (direction) {
                                                
                                        case up:
                                                if (levelpartRow > 0 && levelpartRow < NumberofRows)
                                                {
                                                	if((level.getEmptyLevelPart() != null && level.getneighbour2DArray().get(levelpartRow-1).get(levelpartColumn).getId() != level.getEmptyLevelPart().getId()) || (level.getEmptyLevelPart() == null))
                                                        
                                                        {
                                                
                                             //a levelpart minden falanak
                                              for(int walls =0; walls < levelpart.getWalls().size(); walls++)
                                              {
                                              //minden vertexen vegigmegyunk
                                                  for(int vertex =0; vertex < levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                  {
                                                          if(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getY()==100)
                                                          {
                                                                  //ha az y tengely vegen van vertexe a poligonnak akkor megjegyezzuk
                                                                  levelpartVertexes.add(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                          }
                                                  }
                                                
                                                  //ahol az iranyba levo levelparton, y=0 koordinataban van valamely poligonnak vertexe akkor megjegyezzuk
                                        for(walls =0; walls < level.getneighbour2DArray().get(levelpartRow-1).get(levelpartColumn).getWalls().size(); walls++)
                                        {
                                                  for(int vertex = 0; vertex < level.getneighbour2DArray().get(levelpartRow-1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                  {
                                                          if(level.getneighbour2DArray().get(levelpartRow-1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getY()==0)
                                                          {
                                                                  unknownlevelpartVertexes.add(level.getneighbour2DArray().get(levelpartRow-1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                          }
                                                  }
                                                        //ha nem ugyanannyi van akkor nincs illeszkedes
                                                        if(levelpartVertexes.size() != unknownlevelpartVertexes.size())
                                                        {
                                                                Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                        return false;
                                                        }
                                                        else 
                                                        {
                                                        //ha sorrendhelyesen nem ugyanott van akkor nincs illeszkedes
                                                                //egyebkent igent ad vissza a program
                                                                for(int i=0; i< levelpartVertexes.size(); i++)
                                                                        {
                                                                                if(levelpartVertexes.get(i).getX() != unknownlevelpartVertexes.get(i).getX())
                                                                                {
                                                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                return false;
                                                                                }
                                                                        }
                                                        }
                                           }
                                                        
                                                                                
                                  /*  
                                     //a levelpart minden fal?nak
                                      for(int wall =0; wall < levelpart.getWalls().size(); wall++)
                                      {
                                      //minden vertex?n v?gigmegy?nk
                                          for(int vertex =0; vertex < levelpart.getWalls().get(wall).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                          {
                                          //ha a vertex egyik pontja illeszkedik a plaonra
                                                 if(levelpart.getWalls().get(wall).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getY()==100)
                                                 {
                                                 //v?gigmegy?nk az ?sszes ponton azon a tengelyen
                                                         for(int xcounter=0; xcounter<100;xcounter++)
                                                         {
                                                         //megnezzuk a felette levo levelpart osszes falat
                                                                 for(int levelpartwalls =0; levelpartwalls < new2darray.get(levelpartRow).get(levelpartColumn-1).getWalls().size(); levelpartwalls++)
                                                                 {
                                                                 //azoknak az osszes vertexet
                                                                         for(int vertexcounter = 0; vertexcounter < new2darray.get(levelpartRow).get(levelpartColumn-1).getWalls().get(levelpartwalls).getPhysicalEntity().getPolygon().getVertexes().size(); vertexcounter++)
                                                                         {
                                                                         //es ha van olyan hogy a kapott levelpart feletti levelpart y tengelyen 0 az elmozdulas
                                                                         //(tehat a koordinatak: levelpartnak (x1,100) felette levonek(x2,0) ES x1 = x2) akkor ez a fal jo (a tobbi nembiztos meg)
                                                                         if(levelpart.getWalls().get(wall).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getX() == 
                                                                                 new2darray.get(levelpartRow).get(levelpartColumn-1).getWalls().get(levelpartwalls).getPhysicalEntity().getPolygon().getVertexes().get(vertexcounter).getX()
                                                                                 &&
                                                                                 new2darray.get(levelpartRow).get(levelpartColumn-1).getWalls().get(levelpartwalls).getPhysicalEntity().getPolygon().getVertexes().get(vertexcounter).getY()==0
                                                                                 )
                                                                                 {
                                                                                         
                                                                                 }
                                                                                 
                                                                        //ha barmelyiknel nincs ilyen akkor nincs egyezes
                                                                         else System.out.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                 return false;
                                                                         }
                                                                 }
                                                                
                                                         }
                                                 }        
                                          }
                                        
                                      }
                                      */
                                      
                                           //else return null;
                                              }
                                                        }         
                                                  	  else 
                                                  	  {
                                                            Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                            return false;
                                                  	  }
                                                }
                                                else 
                                                {
                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                        return false;
                                                }
                                              break;
                                                      
                                           
                                        case down:
                                                if ( levelpartRow >= 0 && levelpartRow < NumberofRows-1)
                                                {
                                                	if((level.getEmptyLevelPart() != null && level.getneighbour2DArray().get(levelpartRow+1).get(levelpartColumn).getId() != level.getEmptyLevelPart().getId()) || (level.getEmptyLevelPart() == null))
                                                        
                                                        {
                                             //a levelpart minden fal?nak
                                              for(int walls =0; walls < levelpart.getWalls().size(); walls++)
                                              {
                
                                              //minden vertex?n v?gigmegy?nk
                                                  for(int vertex =0; vertex < levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                  {
                                                
                                                          if(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getY()==0)
                                                          {
                                                                  levelpartVertexes.add(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                          }
                                                  }
                                                  
                                                        for(walls =0; walls < new2darray.get(levelpartRow+1).get(levelpartColumn).getWalls().size(); walls++)
                                                        {
                                                                  for(int vertex = 0; vertex < new2darray.get(levelpartRow+1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                                  {
                                                                          if(new2darray.get(levelpartRow+1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getY()==100)
                                                                          {
                                                                                  unknownlevelpartVertexes.add(new2darray.get(levelpartRow+1).get(levelpartColumn).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                                          }
                                                                  }

                                                                        if(levelpartVertexes.size() != unknownlevelpartVertexes.size())
                                                                        {
                                                                                Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                        return false;
                                                                        }
                                                                        else 
                                                                        {
                                                                                for(int i=0; i< levelpartVertexes.size()-1; i++)
                                                                                        {
                                                                                                if(levelpartVertexes.get(i).getX() != unknownlevelpartVertexes.get(i).getX())
                                                                                                {
                                                                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                                return false;
                                                                                                }
                                                                                        }
                                                                        }

                                                        }  }
                                                        }         
                                                  	  else {
                                                            Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                            return false;
                                                    }
                                                }
                                                else {
                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                        return false;
                                                }
                                           break;
                                           
                                        case right:
                                                     //a levelpart minden fal?nak
                                                if ( levelpartColumn < NumberofColumns-1 && levelpartColumn >= 0)
                                                {
                                                	if((level.getEmptyLevelPart() != null && level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn+1).getId() != level.getEmptyLevelPart().getId()) || (level.getEmptyLevelPart() == null))
                                                      for(int walls =0; walls < levelpart.getWalls().size(); walls++)
                                                      {
                                                      //minden vertex?n v?gigmegy?nk
                                                          for(int vertex =0; vertex < levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                          {
                                                                  if(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getX()==100)
                                                                  {
                                                                          levelpartVertexes.add(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                                  }
                                                          }
                                                          
                                                                for(walls =0; walls < level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn+1).getWalls().size(); walls++)
                                                                {
                                                                          for(int vertex = 0; vertex < level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn+1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                                          {
                                                                                  if(level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn+1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getX()==0)
                                                                                  {
                                                                                          unknownlevelpartVertexes.add(level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn+1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                                                  }
                                                                          }

                                                                                if(levelpartVertexes.size() != unknownlevelpartVertexes.size())
                                                                                {
                                                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                return false;
                                                                                }
                                                                                else 
                                                                                {
                                                                                        for(int i=0; i< levelpartVertexes.size(); i++)
                                                                                                {
                                                                                                        if(levelpartVertexes.get(i).getY() != unknownlevelpartVertexes.get(i).getY())
                                                                                                        {
                                                                                                                Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                                        return false;
                                                                                                        }
                                                                                                }
                                                                                }
                                                                   }
                                                      }         
                        	  else {
                                  Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                  return false;
                          }
                                        }
                                                else {
                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                        return false;
                                                
                                                }
                                                                break;
                                           
                                        case left:
                                                if ( levelpartColumn < NumberofColumns && levelpartColumn > 0)
                                                                {
                                                	if((level.getEmptyLevelPart() != null && level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn-1).getId() != level.getEmptyLevelPart().getId()) || (level.getEmptyLevelPart() == null))
                                                	{
                                                		//a levelpart minden falnak
                                                      for(int walls =0; walls < levelpart.getWalls().size(); walls++)
                                                      {
                                                      //minden vertex?n v?gigmegy?nk
                                                          for(int vertex =0; vertex < levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size(); vertex++)
                                                          {
                                                                  if(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getX()==0)
                                                                  {
                                                                          levelpartVertexes.add(levelpart.getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                                  }
                                                          }
                                                          
                                                                for(walls =0; walls < level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn-1).getWalls().size()-1; walls++)
                                                                {
                                                                          for(int vertex = 0; vertex < level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn-1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().size()-1; vertex++)
                                                                          {
                                                                                  if(level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn-1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex).getX()==100)
                                                                                  {
                                                                                          unknownlevelpartVertexes.add(level.getneighbour2DArray().get(levelpartRow).get(levelpartColumn-1).getWalls().get(walls).getPhysicalEntity().getPolygon().getVertexes().get(vertex));
                                                                                  }
                                                                          }

                                                                                if(levelpartVertexes.size() != unknownlevelpartVertexes.size())
                                                                                {
                                                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                return false;
                                                                                }
                                                                                else 
                                                                                {
                                                                                        for(int i=0; i< levelpartVertexes.size()-1; i++)
                                                                                                {
                                                                                                        if(levelpartVertexes.get(i).getY() != unknownlevelpartVertexes.get(i).getY())
                                                                                                        {
                                                                                                                Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                                                                                        return false;
                                                                                                        }
                                                                                                }
                                                                                }
                                                                   }
                                                      }
                                                                }
                                                                
                                                	  else {
                                                          Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                          return false;
                                                  }
                                                                }
                                                else {
                                                        Controller.println("ESEMENY: a palyaszakaszok NEM illeszkednek");
                                                        return false;
                                                }
                                                break;

                        //ha teljesult az osszes falra a feltetel akkor illeszkedik
                                
                                        }
                                        Controller.println("ESEMENY: a palyaszakaszok illeszkednek");
                                        return true;
        }
        
}
